package com.init.bootframe.system.service.impl;

import com.init.bootframe.system.dao.IOrgDao;
import com.init.bootframe.system.service.IOrgService;
import com.init.bootframe.system.vo.OrgVO;
import com.init.bootframe.util.TmompConstant;
import com.init.bootframe.util.TmompUser;
import com.init.bootframe.util.TmompUtils;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class OrgServiceImpl implements IOrgService {

    private static Logger logger = LoggerFactory.getLogger(OrgServiceImpl.class); //日志

    @Autowired
    private IOrgDao orgDao; //组织dao

    /**
     * 组织列表查询
     * @param orgVO
     * @return
     */
    @Override
    public List<OrgVO> findOrgList(OrgVO orgVO) {
        // 角色设置组织code
        orgVO.setOrgCode(TmompUser.getCurrentUserInfo().getOrgCode());
        return orgDao.findOrgs(orgVO);
    }

    /**
     * 添加组织
     * @param orgVO
     * @return
     */
    @Override
    public Map<String, Object> addOrg(OrgVO orgVO) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        try {
            // 随机设置组织编码
            orgVO.setOrgCode(TmompUtils.getOrgCode());
            // 添加组织
            orgDao.addOrg(orgVO);
            // // 角色Id集合
            // String[] roleIds = orgVO.getRoleIds();
            // if (null != roleIds && roleIds.length > 0) {
            // for (int i = 0; i < roleIds.length; i++) {
            // OrgRoleVO orgRoleVO = new OrgRoleVO();
            // orgRoleVO.setRoleId(roleIds[i]);
            // orgRoleVO.setOrgId(orgVO.getOrgId());
            // // 添加角色
            // orgDao.addOrgRole(orgRoleVO);
            // }
            // }
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.TRUE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "添加节点成功！");
            logger.debug("添加节点成功！");
        } catch (Exception e) {
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.FALSE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "添加节点失败！");
            logger.error("添加节点失败！" + e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
        return resultMap;
    }

    /**
     * 更新组织
     * @param orgVO
     * @return
     */
    @Override
    public Map<String, Object> updateOrg(OrgVO orgVO) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        try {
            // 修改组织
            orgDao.updateOrg(orgVO);
            // // 删除所有组织角色
            // OrgRoleVO orgRoleParmVO = new OrgRoleVO();
            // orgRoleParmVO.setOrgId(orgVO.getOrgId());
            // orgDao.deleteOrgRole(orgRoleParmVO);
            // // 角色Id集合
            // String[] roleIds = orgVO.getRoleIds();
            // if (null != roleIds && roleIds.length > 0) {
            // // 循环添加组织角色
            // for (int i = 0; i < roleIds.length; i++) {
            // OrgRoleVO orgRoleVO = new OrgRoleVO();
            // orgRoleVO.setRoleId(roleIds[i]);
            // orgRoleVO.setOrgId(orgVO.getOrgId());
            // // 添加角色
            // orgDao.addOrgRole(orgRoleVO);
            // }
            // }
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.TRUE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "修改节点成功！");
            logger.debug("修改节点成功！");
        } catch (Exception e) {
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.FALSE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "修改节点失败！");
            logger.error("修改节点失败！" + e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
        return resultMap;
    }

    /**
     * 修改批量组织
     * @param orgJson
     *            参数
     * @return
     */
    @Override
    public Map<String, Object> updateBatchOrg(String orgJson) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        try {
            // 设置批量修改菜单集合
            List<OrgVO> orgList = new ArrayList<OrgVO>();
            if (null != orgJson && !"".equals(orgJson)) {
                JSONObject jsonObj = JSONObject.fromObject(orgJson);
                // JSON数组对象
                JSONArray jsonArray = JSONArray.fromObject(jsonObj.get("nodes"));
                // 判断是否为空
                if (null != jsonArray && !jsonArray.isEmpty()) {
                    Object[] os = jsonArray.toArray();
                    for (int i = 0; i < os.length; i++) {
                        // 递归资子元素
                        recursionJSONData(orgList, JSONObject.fromObject(os[i]));
                    }
                }
                if (orgList.size() > 0) {
                    String sort = orgList.get(0).getSortBy();
                    int index = (null != sort && !"".equals(sort) && !"null".equals(sort)) ? Integer.parseInt(sort) : 0;
                    // 循环修改组织菜单
                    for (int j = 0; j < orgList.size(); j++) {
                        OrgVO orgVO = orgList.get(j);
                        orgVO.setSortBy(index + "");
                        orgDao.updateBatchOrg(orgVO);
                        index++;
                    }
                }
            }
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.TRUE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "保存组织成功！");
            logger.debug("修改组织成功！");
        } catch (Exception e) {
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.FALSE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "保存组织失败！");
            logger.error("保存组织失败！" + e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
        return resultMap;
    }

    /**
     * 组织查询（以id获取OrgVO对象）
     * @param orgVO
     * @return
     */
    @Override
    public OrgVO findOrg(OrgVO orgVO) {
        return orgDao.findOrg(orgVO);
    }

    /**
     * 组织删除
     * @param orgVO
     * @return
     */
    @Override
    public Map<String, Object> deleteOrg(OrgVO orgVO) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        try {
            // 删除组织
            orgDao.deleteOrg(orgVO);
            // // 删除所有组织角色
            // OrgRoleVO orgRoleParmVO = new OrgRoleVO();
            // orgRoleParmVO.setOrgId(orgVO.getOrgId());
            // orgDao.deleteOrgRole(orgRoleParmVO);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.TRUE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "删除节点成功！");
            logger.debug("删除节点成功！");
        } catch (Exception e) {
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_RESULT, Boolean.FALSE);
            resultMap.put(TmompConstant.BaseDataConstant.DEFAULT_VALUE_MSG, "删除节点失败！");
            logger.error("删除节点失败！" + e.getMessage());
        }
        return resultMap;
    }

    /**
     * 递归循环解析json数据
     *
     * @param orgList
     * @param jsonObj
     */
    private void recursionJSONData(List<OrgVO> orgList, JSONObject jsonObj) {
        OrgVO orgVO = new OrgVO();
        // 组织Id
        orgVO.setOrgId(jsonObj.get("orgId").toString());
        // 组织父Id
        orgVO.setParentOrgId(jsonObj.get("parentOrgId").toString());
        // 排序
        orgVO.setSortBy(jsonObj.get("sortBy").toString());
        orgList.add(orgVO);
        // 判断是否含有下一级组织
        if (null != jsonObj.get("children")) {
            JSONArray obj = JSONArray.fromObject(jsonObj.get("children"));
            if (null != obj && !obj.isEmpty()) {
                Object[] os = obj.toArray();
                for (int i = 0; i < os.length; i++) {
                    // 调用自身方法
                    recursionJSONData(orgList, JSONObject.fromObject(os[i]));
                }
            }
        }
    }

    /**
     * 查询树状组织信息集合
     *
     * @author chentao
     * @return List<OrgVO>
     */
    public List<OrgVO> getOrgsTreeList(OrgVO parmOrgVO) {
        // 角色设置组织code
        parmOrgVO.setOrgCode(TmompUser.getCurrentUserInfo().getOrgCode());
        // 查询单位信息
        List<OrgVO> unitList = orgDao.findOrgs(parmOrgVO);
        // 获取节点最上层的Id
        int id = 0;
        if (null != unitList && unitList.size() > 0) {
            for (int i = 0; i < unitList.size(); i++) {
                int parentId = Integer.parseInt(unitList.get(i).getParentOrgId());
                if (i == 0) {
                    id = parentId;
                } else {
                    id = parentId > id ? id : parentId;
                }
            }
        }
        // 将单位数据组装成树状结构集合数据
        List<OrgVO> newUnitList = new ArrayList<OrgVO>();
        if (null != unitList && unitList.size() > 0) {
            for (int i = 0; i < unitList.size(); i++) {
                OrgVO OrgVO = unitList.get(i);
                if ((id + "").equals(OrgVO.getParentOrgId())) {
                    installRecursionData(OrgVO, unitList);
                    newUnitList.add(OrgVO);
                }
            }
        }
        return newUnitList;
    }
    /**
     * 递归，判断当前节点下面是否含有子节点
     *
     * @param unitVO
     * @param unitList
     */
    private void installRecursionData(OrgVO unitVO, List<OrgVO> unitList) {
        List<OrgVO> childUnitList = new ArrayList<OrgVO>();
        for (int i = 0; i < unitList.size(); i++) {
            OrgVO childUnitVO = unitList.get(i);
            if (unitVO.getOrgId().equals(childUnitVO.getParentOrgId())) {
                installRecursionData(childUnitVO, unitList);
                childUnitList.add(childUnitVO);
            }
        }
        unitVO.setChildOrgs(childUnitList.size() > 0 ? childUnitList : null);
    }

}
